//!AsRef 和 AsMut
//AsRef
// AsRef 提供了一个方法 .as_ref()。
//
// 对于一个类型为 T 的对象 foo，如果 T 实现了 AsRef<U>，那么，foo 可执行 .as_ref() 操作，即 foo.as_ref()。
// 操作的结果，我们得到了一个类型为 &U 的新引用。
//
// 注：
//
// 与 Into<T> 不同的是，AsRef<T> 只是类型转换，foo 对象本身没有被消耗；
// T: AsRef<U> 中的 T，可以接受 资源拥有者（owned）类型，共享引用（shared referrence）类型 ，可变引用（mutable referrence）类型。
struct Counter{
    count: u32,
}

impl AsRef<u32> for Counter{
    fn as_ref(&self) -> &u32 {
        &self.count
    }
}

#[test]
pub fn asref_demo(){
    let counter = Counter{count: 34};
    println!("{}", counter.as_ref());
    println!("{}", counter.as_ref());
}

//AsMut
// AsMut<T> 提供了一个方法 .as_mut()。它是 AsRef<T> 的可变（mutable）引用版本。
//
// 对于一个类型为 T 的对象 foo，如果 T 实现了 AsMut<U>，那么，foo 可执行 .as_mut() 操作，即 foo.as_mut()。操作的结果，我们得到了一个类型为 &mut U 的可变（mutable）引用。
//
// 注：在转换的过程中，foo 会被可变（mutable）借用。

impl AsMut<u32> for Counter{
    fn as_mut(&mut self) -> &mut u32 {
        &mut self.count
    }
}

#[test]
pub fn asmut_demo(){
    let mut counter = Counter{count: 34};
    let r = counter.as_mut();
    *r = 45;
    println!("{}", counter.count); //45
    println!("{}", counter.as_ref()); //45
    let x = counter.as_mut();
    *x =34;
    println!("{}", counter.as_ref());//34
}